﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DataAccessComponents;
using System.Data.Common;
using System.Data;
using System.Collections.ObjectModel;
using System.Web.Configuration;

namespace DAL
{
    /// <summary>
    /// DataAccesLayer 
    /// Klasa odpowiada za komunikacje z bazą danych 
    /// </summary>
    public class DbOperations
    {
        /// <summary>
        /// ConnectionString do bazy danych
        /// </summary>
        private string connectionString = WebConfigurationManager.ConnectionStrings["biuroPodrozyConnectionString"].ConnectionString;

        /// <summary>
        /// Nazwa provider-a użytej bazy danych
        /// </summary>
        private string dbProvider = WebConfigurationManager.ConnectionStrings["biuroPodrozyConnectionString"].ProviderName;


       

        /// <summary>
        /// Funkcja dodaje nowy adres do tabeli "Adres" w bazie danych 
        /// </summary>
        /// <param name="adres">Obiekt adresu</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajAdres(Adres adres)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_adres";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@ulica";
            param.Value = adres.Ulica;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nr_domu";
            param.Value = adres.Nr_domu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@kod_pocztowy";
            param.Value = adres.Kod_pocztowy;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@wojewodztwo";
            param.Value = adres.Wojewodztwo;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@kraj";
            param.Value = adres.Kraj;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@miasto";
            param.Value = adres.Miasto;
            cmd.Parameters.Add(param);
            
            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());  
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca adres z bazy danych na postawie id_adres
        /// </summary>
        /// <param name="idadres">Id adresu to usnięcia</param>
        public void usunAdres(int idadres){
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_adres";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_adres";
            param.Value = idadres;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca adres w bazie danych
        /// </summary>
        /// <param name="adres">Obiekt adres do zawierający inforamacje do aktualizacji</param>
        public void aktualizujAdres(Adres adres)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_adres";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_adres";
            param.Value = adres.Id_adres;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@ulica";
            param.Value = adres.Ulica;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nr_domu";
            param.Value = adres.Nr_domu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@kod_pocztowy";
            param.Value = adres.Kod_pocztowy;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@wojewodztwo";
            param.Value = adres.Wojewodztwo;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@kraj";
            param.Value = adres.Kraj;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@miasto";
            param.Value = adres.Miasto;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();

            conn.Close();
                
        }
        
        /// <summary>
        /// Pobiera adres na podstawie id adres
        /// </summary>
        /// <param name="idadres">Id adres</param>
        /// <returns>Obiekt Adres</returns>
        public Adres pobierzAdres(int idadres)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_adres";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_adres";
            param.Value = idadres;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Adres adres = new Adres();
            while (rdr.Read())
            {
                adres.Id_adres = (int)rdr["id_adres"];
                adres.Ulica = (string)rdr["ulica"];
                adres.Nr_domu = (string)rdr["nr_domu"];
                adres.Kod_pocztowy = (string)rdr["kod_pocztowy"];
                adres.Wojewodztwo = (string)rdr["wojewodztwo"];
                adres.Kraj = (string)rdr["kraj"];
                adres.Miasto = (string)rdr["miasto"];
                    
            }
            rdr.Close();
            conn.Close();

            return adres;

        }

        /// <summary>
        /// Pobiera liste adresów
        /// </summary>        
        /// <returns>Obiekt Adres</returns>
        public ObservableCollection<Adres> pobierzListeAdres()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_adres";
            cmd.CommandType = CommandType.StoredProcedure;  

            

            DbDataReader rdr = cmd.ExecuteReader();

            Adres adres = new Adres();
            ObservableCollection<Adres> listaAdres = new ObservableCollection<Adres>();
            while (rdr.Read())
            {
                adres.Id_adres = (int)rdr["id_adres"];
                adres.Ulica = (string)rdr["ulica"];
                adres.Nr_domu = (string)rdr["nr_domu"];
                adres.Kod_pocztowy = (string)rdr["kod_pocztowy"];
                adres.Wojewodztwo = (string)rdr["wojewodztwo"];
                adres.Kraj = (string)rdr["kraj"];
                adres.Miasto = (string)rdr["miasto"];

                listaAdres.Add(adres);
                adres = new Adres();

            }
            rdr.Close();
            conn.Close();

            return listaAdres;

        }

        /// <summary>
        /// Funkcja dodaje nową galerie do tabeli "Galeria" w bazie danych 
        /// </summary>
        /// <param name="galeria">Obiekt galeria</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajGalerie(Galeria galeria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_galerie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = galeria.Nazwa;
            cmd.Parameters.Add(param);


            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());  
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca galerie z bazy danych na postawie id_galeria
        /// </summary>
        /// <param name="idgaleria">Id galeri to usnięcia</param>
        public void usunGalerie(int idgaleria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_galerie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_galeria";
            param.Value = idgaleria;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca galerie w bazie danych
        /// </summary>
        /// <param name="galeria">Obiekt galeria zawierający inforamacje do aktualizacji</param>
        public void aktualizujGalerie(Galeria galeria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_galerie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_galeria";
            param.Value = galeria.Id_galeria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = galeria.Nazwa;
            cmd.Parameters.Add(param);         

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera Galerie na podstawie id galeria
        /// </summary>
        /// <param name="idgaleria">Id galeria</param>
        /// <returns>Obiekt Galeria</returns>
        public Galeria pobierzGalerie(int idgaleria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_galerie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_galeria";
            param.Value = idgaleria;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Galeria galeria = new Galeria();
            while (rdr.Read())
            {
                galeria.Id_galeria = (int)rdr["id_galeria"];
                galeria.Nazwa = (string)rdr["nazwa"];
            }
            rdr.Close();
            conn.Close();

            return galeria;

        }


        public Zdjecie pobierzZdjecieGlowneGaleria(int idgaleria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_zdjecie_galeria";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_galeria";
            param.Value = idgaleria;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Zdjecie zdjecie = new Zdjecie();
            while (rdr.Read())
            {
                zdjecie.Id_zdjecia = (int)rdr["id_zdjecia"];
                zdjecie.Nazwa = (string)rdr["nazwa"];
                zdjecie.Zdjecie1 = (byte[])rdr["zdjecie"];
            }
            rdr.Close();
            conn.Close();

            return zdjecie;
        }

        /// <summary>
        /// Funkcja dodaje nowy hotel do tabeli "Hotel" w bazie danych 
        /// </summary>
        /// <param name="hotel">Obiekt Hotel</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajHotel(Hotel hotel)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_hotel";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = hotel.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = hotel.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = hotel.Opis_skrot;
            cmd.Parameters.Add(param);
            
            param = provider.CreateParameter();
            param.ParameterName = "@id_galeria";
            param.Value = hotel.Id_galeria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_miasta";
            param.Value = hotel.Id_miasta;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@standard";
            param.Value = hotel.Standard;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_wyzywienie";
            param.Value = hotel.Id_wyzywienie;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());  
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Hotel z bazy danych na postawie id_hotelu
        /// </summary>
        /// <param name="idhotel">Id hotel to usnięcia</param>
        public void usunHotel(int idhotel)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_hotel";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_hotelu";
            param.Value = idhotel;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Hotel w bazie danych
        /// </summary>
        /// <param name="hotel">Obiekt hotel zawierający inforamacje do aktualizacji</param>
        public void aktualizujHotel(Hotel hotel)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_hotel";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_hotelu";
            param.Value = hotel.Id_hotelu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = hotel.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = hotel.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = hotel.Opis_skrot;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_galeria";
            param.Value = hotel.Id_galeria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_miasta";
            param.Value = hotel.Id_miasta;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@standard";
            param.Value = hotel.Standard;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_wyzywienie";
            param.Value = hotel.Id_wyzywienie;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera hotel na podstawie id hotel
        /// </summary>
        /// <param name="idhotel">Id hotel</param>
        /// <returns>Obiekt Hotel</returns>
        public Hotel pobierzHotel(int idhotel)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_hotel";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_hotelu";
            param.Value = idhotel;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Hotel hotel = new Hotel();
            while (rdr.Read())
            {
                hotel.Id_hotelu = (int)rdr["id_hotelu"];
                hotel.Nazwa = (string)rdr["nazwa"];
                hotel.Opis = (string)rdr["opis"];
                hotel.Opis_skrot = (string)rdr["opis_skrot"];
                hotel.Id_galeria = (int)rdr["id_galeria"];
                hotel.Id_miasta = (int)rdr["id_miasta"];
                hotel.Standard = (string)rdr["standard"];
                hotel.Id_wyzywienie = (int)rdr["id_wyzywienie"];
            }
            rdr.Close();
            conn.Close();

            return hotel;
        }

        public ObservableCollection<Hotel> pobierzListeHotel(int idmiasta=0)
        {
            ObservableCollection<Hotel> listaHotel = new ObservableCollection<Hotel>();
            Hotel hotel = new Hotel();
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;

            //otawarcie połączenia
            conn.Open();

            //wywołanie procedury składowanej
            cmd.CommandText = "pobierz_liste_hotel";
            cmd.CommandType = CommandType.StoredProcedure;
            
            // Sprawdzenie czy podano idmiasta
            if (idmiasta > 0)
            {
                DbParameter param = provider.CreateParameter();
                param.ParameterName = "@id_miasta";
                param.Value = idmiasta;
                cmd.Parameters.Add(param);
            }

            DbDataReader rdr = cmd.ExecuteReader();

            while (rdr.Read())
            {
                hotel.Id_hotelu = (int)rdr["id_hotelu"];
                hotel.Nazwa = (string)rdr["nazwa"];
                hotel.Opis = (string)rdr["opis"];
                hotel.Opis_skrot = (string)rdr["opis_skrot"];
                hotel.Id_galeria = (int)rdr["id_galeria"];
                hotel.Id_miasta = (int)rdr["id_miasta"];
                hotel.Standard = (string)rdr["standard"];
                hotel.Id_wyzywienie = (int)rdr["id_wyzywienie"];

                // Dodawanie hotel do listy hoteli
                listaHotel.Add(hotel);

                //tworzenie nowego obiektu
                hotel = new Hotel();

            }
            rdr.Close();
            conn.Close();

            return listaHotel;


        }

        public ObservableCollection<Hotel> pobierzListeHotelZTerminem()
        {
            ObservableCollection<Hotel> listaHotel = new ObservableCollection<Hotel>();
            Hotel hotel = new Hotel();
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;

            //otawarcie połączenia
            conn.Open();

            //wywołanie procedury składowanej
            cmd.CommandText = "pobierz_liste_hotel";
            cmd.CommandType = CommandType.StoredProcedure;

            
                DbParameter param = provider.CreateParameter();
                param.ParameterName = "@termin";
                param.Value = 1;
                cmd.Parameters.Add(param);
            

            DbDataReader rdr = cmd.ExecuteReader();

            while (rdr.Read())
            {
                hotel.Id_hotelu = (int)rdr["id_hotelu"];
                hotel.Nazwa = (string)rdr["nazwa"];
                hotel.Opis = (string)rdr["opis"];
                hotel.Opis_skrot = (string)rdr["opis_skrot"];
                hotel.Id_galeria = (int)rdr["id_galeria"];
                hotel.Id_miasta = (int)rdr["id_miasta"];
                hotel.Standard = (string)rdr["standard"];
                hotel.Id_wyzywienie = (int)rdr["id_wyzywienie"];
                hotel.Id_termin = (int)rdr["id_termin"];
                // Dodawanie hotel do listy hoteli
                listaHotel.Add(hotel);

                //tworzenie nowego obiektu
                hotel = new Hotel();

            }
            rdr.Close();
            conn.Close();

            return listaHotel;


        }

        /// <summary>
        /// Funkcja dodaje nowy kraj do tabeli "Kraj" w bazie danych 
        /// </summary>
        /// <param name="kraj">Obiekt Kraj</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajKraj(Kraj kraj)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_kraj";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = kraj.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = kraj.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_galeria";
            param.Value = kraj.Id_galeria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = kraj.Opis_skrot;
            cmd.Parameters.Add(param);
            
            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());            
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Kraj z bazy danych na postawie id_kraju
        /// </summary>
        /// <param name="idkraj">Id kraj to usnięcia</param>
        public void usunKraj(int idkraj)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_kraj";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_kraju";
            param.Value = idkraj;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Kraj w bazie danych
        /// </summary>
        /// <param name="kraj">Obiekt kraj zawierający inforamacje do aktualizacji</param>
        public void aktualizujKraj(Kraj kraj)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_kraj";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_kraju";
            param.Value = kraj.Id_kraju;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = kraj.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = kraj.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_galeria";
            param.Value = kraj.Id_galeria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = kraj.Opis_skrot;
            cmd.Parameters.Add(param);
            

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera kraj na podstawie id kraj
        /// </summary>
        /// <param name="idkraj">Id kraj</param>
        /// <returns>Obiekt Kraj</returns>
        public Kraj pobierzKraj(int idkraj)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_kraj";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_kraju";
            param.Value = idkraj;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Kraj kraj = new Kraj();
            while (rdr.Read())
            {
                kraj.Id_kraju = (int)rdr["id_kraju"];
                kraj.Nazwa = (string)rdr["nazwa"];
                kraj.Opis = (string)rdr["opis"];
                kraj.Id_galeria = (int)rdr["id_galeria"];
                kraj.Opis_skrot = (string)rdr["opis_skrot"];
            }
            rdr.Close();
            conn.Close();

            return kraj;
        }

        /// <summary>
        /// Funkcja zwracająca listę krajów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<Kraj> pobierzListeKraj()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_kraj";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            Kraj kraj = new Kraj();
            ObservableCollection<Kraj> listaKrajow = new ObservableCollection<Kraj>();
            while (rdr.Read())
            {
               
                kraj.Id_kraju = (int)rdr["id_kraju"];
                kraj.Nazwa = (string)rdr["nazwa"];
                kraj.Opis = (string)rdr["opis"];
                kraj.Id_galeria = (int)rdr["id_galeria"];
                kraj.Opis_skrot = (string)rdr["opis_skrot"];


                listaKrajow.Add(kraj);
                kraj = new Kraj();
            }
            rdr.Close();
            conn.Close();

            return listaKrajow;
        }

        /// <summary>
        /// Funkcja dodaje nowy daneFirma do tabeli "DaneFirma" w bazie danych 
        /// </summary>
        /// <param name="daneFirma">Obiekt DaneFirma</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajDaneFirma(DaneFirma daneFirma)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_daneFirma";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = daneFirma.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = daneFirma.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_adres";
            param.Value = daneFirma.Id_adres;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@haslo_smtp";
            param.Value = daneFirma.Haslo_smtp;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@login_smtp";
            param.Value = daneFirma.Login_smtp;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@host_smtp";
            param.Value = daneFirma.Host_smtp;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@haslo_sms";
            param.Value = daneFirma.Haslo_sms;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@login_sms";
            param.Value = daneFirma.Login_sms;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@host_sms";
            param.Value = daneFirma.Host_sms;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@email_smtp";
            param.Value = daneFirma.Email_smtp;
            cmd.Parameters.Add(param);


            int indeksDodanegoWiersza = 0;//Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca DaneFirma z bazy danych na postawie id_daneFirmau
        /// </summary>
        /// <param name="iddaneFirma">Id daneFirma to usnięcia</param>
        public void usunDaneFirma(string nazwa)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_daneFirma";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@nazwa";
            param.Value = nazwa;
            cmd.Parameters.Add(param);

           

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca DaneFirma w bazie danych
        /// </summary>
        /// <param name="daneFirma">Obiekt daneFirma zawierający inforamacje do aktualizacji</param>
        public void aktualizujDaneFirma(DaneFirma daneFirma)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_daneFirma";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury                     
            param.ParameterName = "@nazwa";
            param.Value = daneFirma.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = daneFirma.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_adres";
            param.Value = daneFirma.Id_adres;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@haslo_smtp";
            param.Value = daneFirma.Haslo_smtp;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@login_smtp";
            param.Value = daneFirma.Login_smtp;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@host_smtp";
            param.Value = daneFirma.Host_smtp;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@haslo_sms";
            param.Value = daneFirma.Haslo_sms;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@login_sms";
            param.Value = daneFirma.Login_sms;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@host_sms";
            param.Value = daneFirma.Host_sms;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@email_smtp";
            param.Value = daneFirma.Email_smtp;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera daneFirma na podstawie id daneFirma
        /// </summary>
        /// <param name="iddaneFirma">Id daneFirma</param>
        /// <returns>Obiekt DaneFirma</returns>
        public DaneFirma pobierzDaneFirma(string nazwa)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_daneFirma";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@nazwa";
            param.Value = nazwa;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            DaneFirma daneFirma = new DaneFirma();
            while (rdr.Read())
            {
                
                daneFirma.Nazwa = (string)rdr["nazwa"];
                daneFirma.Opis = (string)rdr["opis"];
                daneFirma.Id_adres = (int)rdr["id_adres"];
                daneFirma.Haslo_smtp = (string)rdr["haslo_smtp"];
                daneFirma.Login_smtp = (string)rdr["login_smtp"];
                daneFirma.Host_smtp = (string)rdr["host_smtp"];
                daneFirma.Email_smtp = (string)rdr["email_smtp"];

                daneFirma.Haslo_sms = (string)rdr["haslo_sms"];
                daneFirma.Login_sms = (string)rdr["login_sms"];
                daneFirma.Host_sms = (string)rdr["host_sms"];


            }
            rdr.Close();
            conn.Close();

            return daneFirma;
        }

        /// <summary>
        /// Funkcja dodaje nowy oddzial do tabeli "Oddzial" w bazie danych 
        /// </summary>
        /// <param name="oddzial">Obiekt Oddzial</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajOddzial(Oddzial oddzial)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_oddzial";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = oddzial.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nr_telefonu";
            param.Value = oddzial.Nr_telefonu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_adres";
            param.Value = oddzial.Id_adres;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Oddzial z bazy danych na postawie id_oddzial
        /// </summary>
        /// <param name="idoddzial">Id oddzial to usnięcia</param>
        public void usunOddzial(int idoddzial)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_oddzial";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_oddzial";
            param.Value = idoddzial;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Oddzial w bazie danych
        /// </summary>
        /// <param name="oddzial">Obiekt oddzial zawierający inforamacje do aktualizacji</param>
        public void aktualizujOddzial(Oddzial oddzial)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_oddzial";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_oddzial";
            param.Value = oddzial.Id_oddzial;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = oddzial.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nr_telefonu";
            param.Value = oddzial.Nr_telefonu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_adres";
            param.Value = oddzial.Id_adres;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera oddzial na podstawie id oddzial
        /// </summary>
        /// <param name="idoddzial">Id oddzial</param>
        /// <returns>Obiekt Oddzial</returns>
        public Oddzial pobierzOddzial(int idoddzial)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_oddzial";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_oddzial";
            param.Value = idoddzial;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Oddzial oddzial = new Oddzial();
            while (rdr.Read())
            {
                oddzial.Id_oddzial = (int)rdr["id_oddzial"];
                oddzial.Nazwa = (string)rdr["nazwa"];
                oddzial.Nr_telefonu = (string)rdr["nr_telefonu"];
                oddzial.Id_adres = (int)rdr["id_adres"];
            }
            rdr.Close();
            conn.Close();

            return oddzial;
        }

        /// <summary>
        /// Funkcja zwracająca listę oddzialów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<Oddzial> pobierzListeOddzial()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_oddzial";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            Oddzial oddzial = new Oddzial();
            ObservableCollection<Oddzial> listaOddzialow = new ObservableCollection<Oddzial>();
            while (rdr.Read())
            {

                oddzial.Id_oddzial = (int)rdr["id_oddzial"];
                oddzial.Nazwa = (string)rdr["nazwa"];
                oddzial.Nr_telefonu = (string)rdr["nr_telefonu"];
                oddzial.Id_adres = (int)rdr["id_adres"];

                listaOddzialow.Add(oddzial);
                oddzial = new Oddzial();
            }
            rdr.Close();
            conn.Close();

            return listaOddzialow;
        }



        /// <summary>
        /// Funkcja dodaje nowy kategoria do tabeli "Kategoria" w bazie danych 
        /// </summary>
        /// <param name="kategoria">Obiekt Kategoria</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajKategoria(Kategoria kategoria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_kategoria";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = kategoria.Nazwa;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Kategoria z bazy danych na postawie id_kategoriau
        /// </summary>
        /// <param name="idkategoria">Id kategoria to usnięcia</param>
        public void usunKategoria(int idkategoria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_kategoria";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_kategoria";
            param.Value = idkategoria;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Kategoria w bazie danych
        /// </summary>
        /// <param name="kategoria">Obiekt kategoria zawierający inforamacje do aktualizacji</param>
        public void aktualizujKategoria(Kategoria kategoria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_kategoria";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_kategoria";
            param.Value = kategoria.Id_kategoria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = kategoria.Nazwa;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera kategoria na podstawie id kategoria
        /// </summary>
        /// <param name="idkategoria">Id kategoria</param>
        /// <returns>Obiekt Kategoria</returns>
        public Kategoria pobierzKategoria(int idkategoria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_kategoria";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_kategoria";
            param.Value = idkategoria;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Kategoria kategoria = new Kategoria();
            while (rdr.Read())
            {
                kategoria.Id_kategoria = (int)rdr["id_kategoria"];
                kategoria.Nazwa = (string)rdr["nazwa"];
            }
            rdr.Close();
            conn.Close();

            return kategoria;
        }

        public ObservableCollection<Kategoria> pobierzListeKategoria()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_kategoria";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();          

            DbDataReader rdr = cmd.ExecuteReader();

            Kategoria kategoria = new Kategoria();
            ObservableCollection<Kategoria> listaKategoria = new ObservableCollection<Kategoria>();
            while (rdr.Read())
            {
                kategoria.Id_kategoria = (int)rdr["id_kategoria"];
                kategoria.Nazwa = (string)rdr["nazwa"];

                listaKategoria.Add(kategoria);
                kategoria = new Kategoria();
            }
            rdr.Close();
            conn.Close();

            return listaKategoria;
        }
        /// <summary>
        /// Funkcja dodaje nowy lotnisko do tabeli "Lotnisko" w bazie danych 
        /// </summary>
        /// <param name="lotnisko">Obiekt Lotnisko</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajLotnisko(Lotnisko lotnisko)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_lotnisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = lotnisko.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_miasta";
            param.Value = lotnisko.Id_miasta;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Lotnisko z bazy danych na postawie id_lotniska
        /// </summary>
        /// <param name="idlotnisko">Id lotnisko to usnięcia</param>
        public void usunLotnisko(int idlotnisko)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_lotnisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_lotniska";
            param.Value = idlotnisko;

            cmd.Parameters.Add(param);
            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Lotnisko w bazie danych
        /// </summary>
        /// <param name="lotnisko">Obiekt lotnisko zawierający inforamacje do aktualizacji</param>
        public void aktualizujLotnisko(Lotnisko lotnisko)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_lotnisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_lotniska";
            param.Value = lotnisko.Id_lotniska;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = lotnisko.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_miasta";
            param.Value = lotnisko.Id_miasta;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera lotnisko na podstawie id lotnisko
        /// </summary>
        /// <param name="idlotnisko">Id lotnisko</param>
        /// <returns>Obiekt Lotnisko</returns>
        public Lotnisko pobierzLotnisko(int idlotnisko)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_lotnisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_lotniska";
            param.Value = idlotnisko;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Lotnisko lotnisko = new Lotnisko();
            while (rdr.Read())
            {
                lotnisko.Id_lotniska = (int)rdr["id_lotniska"];
                lotnisko.Nazwa = (string)rdr["nazwa"];
                lotnisko.Id_miasta = (int)rdr["id_miasta"];
            }
            rdr.Close();
            conn.Close();

            return lotnisko;
        }

        /// <summary>
        /// Funkcja zwraca liste lotnisk znajdujących się w bazie
        /// </summary>
        /// <returns>Lista lotnisk</returns>
        public ObservableCollection<Lotnisko> pobierzListeLotnisko()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_lotnisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();            

            DbDataReader rdr = cmd.ExecuteReader();

            Lotnisko lotnisko = new Lotnisko();
            ObservableCollection<Lotnisko> listaLotnisko = new ObservableCollection<Lotnisko>();
            while (rdr.Read())
            {
                lotnisko.Id_lotniska = (int)rdr["id_lotniska"];
                lotnisko.Nazwa = (string)rdr["nazwa"];
                lotnisko.Id_miasta = (int)rdr["id_miasta"];

                listaLotnisko.Add(lotnisko);
                lotnisko = new Lotnisko();
            }
            rdr.Close();
            conn.Close();

            return listaLotnisko;
        }

        /// <summary>
        /// Funkcja dodaje nowy miasto do tabeli "Miasto" w bazie danych 
        /// </summary>
        /// <param name="miasto">Obiekt Miasto</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajMiasto(Miasto miasto)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_miasto";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = miasto.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_kraju";
            param.Value = miasto.Id_kraju;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = miasto.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@informacje_praktyczne";
            param.Value = miasto.Informacje_praktyczne;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_galeria";
            param.Value = miasto.Id_galeria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = miasto.Opis_skrot;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Miasto z bazy danych na postawie id_miasta
        /// </summary>
        /// <param name="idmiasto">Id miasto to usnięcia</param>
        public void usunMiasto(int idmiasto)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_miasto";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_miasta";
            param.Value = idmiasto;


            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Miasto w bazie danych
        /// </summary>
        /// <param name="miasto">Obiekt miasto zawierający inforamacje do aktualizacji</param>
        public void aktualizujMiasto(Miasto miasto)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_miasto";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_miasta";
            param.Value = miasto.Id_miasta;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = miasto.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_kraju";
            param.Value = miasto.Id_kraju;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = miasto.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@informacje_praktyczne";
            param.Value = miasto.Informacje_praktyczne;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_galeria";
            param.Value = miasto.Id_galeria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = miasto.Opis_skrot;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera miasto na podstawie id miasto
        /// </summary>
        /// <param name="idmiasto">Id miasto</param>
        /// <returns>Obiekt Miasto</returns>
        public Miasto pobierzMiasto(int idmiasto)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_miasto";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_miasta";
            param.Value = idmiasto;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Miasto miasto = new Miasto();
            while (rdr.Read())
            {
                miasto.Id_miasta = (int)rdr["id_miasta"];
                miasto.Nazwa = (string)rdr["nazwa"];
                miasto.Id_kraju = (int)rdr["id_kraju"];
                miasto.Opis = (string)rdr["opis"];
                miasto.Informacje_praktyczne = (string)rdr["informacje_praktyczne"];
                miasto.Id_galeria = (int)rdr["id_galeria"];
                miasto.Opis_skrot = (string)rdr["opis_skrot"];
            }
            rdr.Close();
            conn.Close();

            return miasto;
        }

        /// <summary>
        /// Funkcja zwracająca listę miast dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<Miasto> pobierzListeMiasto(int idkraj=0)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_miasto";
            cmd.CommandType = CommandType.StoredProcedure;

            // Sprawdzanie czy podano id kraju
            if (idkraj > 0)
            {
                DbParameter param = provider.CreateParameter();
                param.ParameterName = "@id_kraj";
                param.Value = idkraj;
                cmd.Parameters.Add(param);
            }

            DbDataReader rdr = cmd.ExecuteReader();

            Miasto miasto = new Miasto();
            ObservableCollection<Miasto> listaMiast = new ObservableCollection<Miasto>();
            while (rdr.Read())
            {
                miasto.Id_miasta = (int)rdr["id_miasta"];
                miasto.Id_kraju = (int)rdr["id_kraju"];
                miasto.Nazwa = (string)rdr["nazwa"];
                miasto.Opis = (string)rdr["opis"];
                miasto.Informacje_praktyczne = (string)rdr["informacje_praktyczne"];
                miasto.Id_galeria = (int)rdr["id_galeria"];
                miasto.Opis_skrot = (string)rdr["opis_skrot"];

                listaMiast.Add(miasto);
                miasto = new Miasto();
            }
            rdr.Close();
            conn.Close();

            return listaMiast;
        }

        /// <summary>
        /// Funkcja dodaje nowy oferta do tabeli "Oferta" w bazie danych 
        /// </summary>
        /// <param name="oferta">Obiekt Oferta</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajOferta(Oferta oferta)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_oferte";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = oferta.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = oferta.Opis;
            cmd.Parameters.Add(param);           

            param = provider.CreateParameter();
            param.ParameterName = "@id_hotelu";
            param.Value = oferta.Id_hotelu;
            cmd.Parameters.Add(param);           

            param = provider.CreateParameter();
            param.ParameterName = "@id_kategoria";
            param.Value = oferta.Id_kategoria;
            cmd.Parameters.Add(param);            

            param = provider.CreateParameter();
            param.ParameterName = "@skrot";
            param.Value = oferta.Skrot;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_linielotnicze";
            param.Value = oferta.Id_linielotnicze;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@typ_pokoju";
            param.Value = oferta.Typ_pokoju;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena_dorosly";
            param.Value = oferta.Cena_dorosly;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena_dziecko";
            param.Value = oferta.Cena_dziecko;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena_dziecko2lata";
            param.Value = oferta.Cena_dziecko2lata;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Oferta z bazy danych na postawie id_oferta
        /// </summary>
        /// <param name="idoferta">Id oferta to usnięcia</param>
        public void usunOferta(int idoferta)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_oferte";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_oferta";
            param.Value = idoferta;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Oferta w bazie danych
        /// </summary>
        /// <param name="oferta">Obiekt oferta zawierający inforamacje do aktualizacji</param>
        public void aktualizujOferta(Oferta oferta)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_oferte";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_oferta";
            param.Value = oferta.Id_oferta;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = oferta.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = oferta.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_hotelu";
            param.Value = oferta.Id_hotelu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_kategoria";
            param.Value = oferta.Id_kategoria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@skrot";
            param.Value = oferta.Skrot;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_linielotnicze";
            param.Value = oferta.Id_linielotnicze;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@typ_pokoju";
            param.Value = oferta.Typ_pokoju;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena_dorosly";
            param.Value = oferta.Cena_dorosly;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena_dziecko";
            param.Value = oferta.Cena_dziecko;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena_dziecko2lata";
            param.Value = oferta.Cena_dziecko2lata;
            cmd.Parameters.Add(param);

           

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera oferta na podstawie id oferta
        /// </summary>
        /// <param name="idoferta">Id oferta</param>
        /// <returns>Obiekt Oferta</returns>
        public Oferta pobierzOferta(int idoferta)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_oferte";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_oferta";
            param.Value = idoferta;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Oferta oferta = new Oferta();
            while (rdr.Read())
            {
                oferta.Id_oferta = (int)rdr["id_oferta"];
                oferta.Nazwa = (string)rdr["nazwa"];
                oferta.Opis = (string)rdr["opis"];           
                oferta.Id_hotelu = (int)rdr["id_hotelu"];
                oferta.Id_linielotnicze = (int)rdr["id_linielotnicze"];
                
                oferta.Skrot = (string)rdr["skrot"];
                
                oferta.Id_kategoria = (int)rdr["id_kategoria"];
                oferta.Typ_pokoju = (string)rdr["typ_pokoju"];

                oferta.Cena_dorosly = (Decimal)rdr["cena_dorosly"];
                oferta.Cena_dziecko = (Decimal)rdr["cena_dziecko"];
                oferta.Cena_dziecko2lata = (Decimal)rdr["cena_dziecko2lata"];
                
            }
            rdr.Close();

            // Pobieranie ilosci terminow
            cmd = provider.CreateCommand();
            cmd.Connection = conn;

            cmd.CommandText = "pobierz_termin_ilosc";
            cmd.CommandType = CommandType.StoredProcedure;

            param = provider.CreateParameter();
            param.ParameterName = "@id_oferta";
            param.Value = oferta.Id_oferta;
            cmd.Parameters.Add(param);
            rdr = cmd.ExecuteReader();
            while (rdr.Read())
            {
                oferta.Ilosc_terminow = (int)rdr["ilosc"];
            }
            rdr.Close();


            conn.Close();

            return oferta;
        }

        /// <summary>
        /// Funkcja zwraca liste ofert w bazie
        /// </summary>
        /// <returns></returns>
        public ObservableCollection<Oferta> pobierzListaOferta()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_oferta";
            cmd.CommandType = CommandType.StoredProcedure;

                      

            DbDataReader rdr = cmd.ExecuteReader();

            Oferta oferta = new Oferta();
            ObservableCollection<Oferta> listOfert = new ObservableCollection<Oferta>();
            while (rdr.Read())
            {
                oferta.Id_oferta = (int)rdr["id_oferta"];
                oferta.Nazwa = (string)rdr["nazwa"];
                oferta.Opis = (string)rdr["opis"];           
                oferta.Id_hotelu = (int)rdr["id_hotelu"];
                oferta.Id_linielotnicze = (int)rdr["id_linielotnicze"];
                
                oferta.Skrot = (string)rdr["skrot"];
                oferta.Id_kategoria = (int)rdr["id_kategoria"];
                oferta.Typ_pokoju = (string)rdr["typ_pokoju"];

                oferta.Cena_dorosly = (Decimal)rdr["cena_dorosly"];
                oferta.Cena_dziecko = (Decimal)rdr["cena_dziecko"];
                oferta.Cena_dziecko2lata = (Decimal)rdr["cena_dziecko2lata"];
                

                listOfert.Add(oferta);
                oferta = new Oferta();
            }
            rdr.Close();

            // Pobieranie ilosci terminowo dla kazdej oferty
            

            DbParameter param = provider.CreateParameter();
            
            foreach (Oferta ofe in listOfert)
            {
                cmd = provider.CreateCommand();
                cmd.Connection = conn;

                cmd.CommandText = "pobierz_termin_ilosc";
                cmd.CommandType = CommandType.StoredProcedure;
                
                param = provider.CreateParameter();
                param.ParameterName = "@id_oferta";
                param.Value = ofe.Id_oferta;
                cmd.Parameters.Add(param);
                rdr = cmd.ExecuteReader();
                while (rdr.Read())
                {
                    ofe.Ilosc_terminow = (int)rdr["ilosc"];
                }
                rdr.Close();
            }    

            conn.Close();
            return listOfert;
        }

        /// <summary>
        /// Funkcja dodaje nowy pracownik do tabeli "Pracownicy" w bazie danych 
        /// </summary>
        /// <param name="pracownik">Obiekt Pracownik</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajPracownik(Pracownik pracownik)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_pracownik";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

           param = provider.CreateParameter();
            param.ParameterName = "@imie";
            param.Value = pracownik.Imie;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwisko";
            param.Value = pracownik.Nazwisko;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_stanowiska";
            param.Value = pracownik.Id_stanowiska;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_uprawnienia";
            param.Value = pracownik.Id_uprawnienia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_aktywnosci";
            param.Value = pracownik.Data_aktywnosci;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_rejestracji";
            param.Value = pracownik.Data_rejestracji;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_adres";
            param.Value = pracownik.Id_adres;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@czy_zablokowany";
            param.Value = pracownik.Czy_zablokowany;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@email";
            param.Value = pracownik.Email;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_oddzial";
            param.Value = pracownik.Id_oddzial;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@haslo";
            param.Value = pracownik.Haslo;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Pracownik z bazy danych na postawie id_pracownik
        /// </summary>
        /// <param name="idpracownik">Id pracownik to usnięcia</param>
        public void usunPracownik(int idpracownik)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_pracownik";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_pracownik";
            param.Value = idpracownik;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Pracownik w bazie danych
        /// </summary>
        /// <param name="pracownik">Obiekt pracownik zawierający inforamacje do aktualizacji</param>
        public void aktualizujPracownik(Pracownik pracownik)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_pracownik";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_pracownik";
            param.Value = pracownik.Id_pracownik;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@imie";
            param.Value = pracownik.Imie;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwisko";
            param.Value = pracownik.Nazwisko;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_stanowiska";
            param.Value = pracownik.Id_stanowiska;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_uprawnienia";
            param.Value = pracownik.Id_uprawnienia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_aktywnosci";
            param.Value = pracownik.Data_aktywnosci;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_rejestracji";
            param.Value = pracownik.Data_rejestracji;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_adres";
            param.Value = pracownik.Id_adres;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@czy_zablokowany";
            param.Value = pracownik.Czy_zablokowany;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@email";
            param.Value = pracownik.Email;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_oddzial";
            param.Value = pracownik.Id_oddzial;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@haslo";
            param.Value = pracownik.Haslo;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera pracownik na podstawie id pracownik
        /// </summary>
        /// <param name="idpracownik">Id pracownik</param>
        /// <returns>Obiekt Pracownik</returns>
        public Pracownik pobierzPracownik(int idpracownik)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_pracownik";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_pracownik";
            param.Value = idpracownik;
            cmd.Parameters.Add(param);            

            DbDataReader rdr = cmd.ExecuteReader();

            Pracownik pracownik = new Pracownik();
            while (rdr.Read())
            {
                pracownik.Id_pracownik = (int)rdr["id_pracownik"];
                pracownik.Imie = (string)rdr["imie"];
                pracownik.Nazwisko = (string)rdr["nazwisko"];
                pracownik.Id_stanowiska = (int)rdr["id_stanowiska"];
                pracownik.Id_uprawnienia = (int)rdr["id_uprawnienia"];
                pracownik.Data_aktywnosci = (DateTime)rdr["data_aktywnosci"];
                pracownik.Data_rejestracji = (DateTime)rdr["data_rejestracji"];
                pracownik.Id_adres = (int)rdr["id_adres"];
                pracownik.Czy_zablokowany = (bool)rdr["czy_zablokowany"];
                pracownik.Email = (string)rdr["email"];
                pracownik.Id_oddzial = (int)rdr["id_oddzial"];
                pracownik.Haslo = (string)rdr["haslo"];
            }
            rdr.Close();
            conn.Close();

            return pracownik;
        }

        /// <summary>
        /// Funkcja zwraca listę pracowników pobranych z bazy danych
        /// </summary>
        /// <returns>Kolekcje obiektów Pracownik</returns>
        public ObservableCollection<Pracownik> pobierzListePracownikow()
        {
            Pracownik pracownik = new Pracownik();
            ObservableCollection<Pracownik> listaPracownikow = new ObservableCollection<Pracownik>();

            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_pracownikow";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            while (rdr.Read())
            {
                
                pracownik.Id_pracownik = (int)rdr["id_pracownik"];
                pracownik.Imie = (string)rdr["imie"];
                pracownik.Nazwisko = (string)rdr["nazwisko"];
                pracownik.Id_stanowiska = (int)rdr["id_stanowiska"];
                pracownik.Id_uprawnienia = (int)rdr["id_uprawnienia"];
                pracownik.Data_aktywnosci = (DateTime)rdr["data_aktywnosci"];
                pracownik.Data_rejestracji = (DateTime)rdr["data_rejestracji"];
                pracownik.Id_adres = (int)rdr["id_adres"];
                pracownik.Nazwa_stanowisko = (string)rdr["nazwa"];
                pracownik.Nazwa_uprawnienie = (string)rdr["nazwa_uprawnienie"];
                pracownik.Czy_zablokowany = (bool)rdr["czy_zablokowany"];
                pracownik.Email = (string)rdr["email"];
                pracownik.Id_oddzial = (int)rdr["id_oddzial"];
                pracownik.Haslo = (string)rdr["haslo"];

                listaPracownikow.Add(pracownik);
                pracownik = new Pracownik();
            }
            rdr.Close();
            conn.Close();

            return listaPracownikow;
        }


        /// <summary>
        /// Funkcja dodaje nowy stanowisko do tabeli "Stanowisko" w bazie danych 
        /// </summary>
        /// <param name="stanowisko">Obiekt Stanowisko</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajStanowisko(Stanowisko stanowisko)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_stanowisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = stanowisko.Nazwa;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Stanowisko z bazy danych na postawie id_stanowiska
        /// </summary>
        /// <param name="idstanowisko">Id stanowisko to usnięcia</param>
        public void usunStanowisko(int idstanowisko)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_stanowisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_stanowiska";
            param.Value = idstanowisko;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Stanowisko w bazie danych
        /// </summary>
        /// <param name="stanowisko">Obiekt stanowisko zawierający inforamacje do aktualizacji</param>
        public void aktualizujStanowisko(Stanowisko stanowisko)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_stanowisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_stanowiska";
            param.Value = stanowisko.Id_stanowiska;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = stanowisko.Nazwa;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera stanowisko na podstawie id stanowiska
        /// </summary>
        /// <param name="idstanowisko">Id stanowisko</param>
        /// <returns>Obiekt Stanowisko</returns>
        public Stanowisko pobierzStanowisko(int idstanowisko)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_stanowisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_stanowiska";
            param.Value = idstanowisko;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Stanowisko stanowisko = new Stanowisko();
            while (rdr.Read())
            {
                stanowisko.Id_stanowiska = (int)rdr["id_stanowiska"];
                stanowisko.Nazwa = (string)rdr["nazwa"];
            }
            rdr.Close();
            conn.Close();

            return stanowisko;
        }

        public ObservableCollection<Stanowisko> pobierzListeStanowisko()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_stanowisko";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            Stanowisko stanowisko = new Stanowisko();
            ObservableCollection<Stanowisko> listaStanowisko = new ObservableCollection<Stanowisko>();
            while (rdr.Read())
            {
                stanowisko.Id_stanowiska = (int)rdr["id_stanowiska"];
                stanowisko.Nazwa = (string)rdr["nazwa"];

                listaStanowisko.Add(stanowisko);
                stanowisko = new Stanowisko();
            }
            rdr.Close();
            conn.Close();

            return listaStanowisko;
        }

        /// <summary>
        /// Funkcja dodaje nowy status do tabeli "Status" w bazie danych 
        /// </summary>
        /// <param name="status">Obiekt Status</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajStatus(Status status)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_status";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = status.Nazwa;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Status z bazy danych na postawie id_status
        /// </summary>
        /// <param name="idstatus">Id status to usnięcia</param>
        public void usunStatus(int idstatus)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_status";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_status";
            param.Value = idstatus;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Status w bazie danych
        /// </summary>
        /// <param name="status">Obiekt status zawierający inforamacje do aktualizacji</param>
        public void aktualizujStatus(Status status)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_status";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_status";
            param.Value = status.Id_status;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = status.Nazwa;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera status na podstawie id status
        /// </summary>
        /// <param name="idstatus">Id status</param>
        /// <returns>Obiekt Status</returns>
        public Status pobierzStatus(int idstatus)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_status";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_status";
            param.Value = idstatus;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Status status = new Status();
            while (rdr.Read())
            {
                status.Id_status = (int)rdr["id_status"];
                status.Nazwa = (string)rdr["nazwa"];
            }
            rdr.Close();
            conn.Close();

            return status;
        }

        /// <summary>
        /// Pobiera liste wartosci z tabeli status
        /// </summary>        
        /// <returns>Liste Status</returns>
        public ObservableCollection<Status> pobierzListeStatus()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_status";
            cmd.CommandType = CommandType.StoredProcedure;

                        

            DbDataReader rdr = cmd.ExecuteReader();

            Status status = new Status();
            ObservableCollection<Status> listaStatus = new ObservableCollection<Status>();
            while (rdr.Read())
            {
                status.Id_status = (int)rdr["id_status"];
                status.Nazwa = (string)rdr["nazwa"];

                listaStatus.Add(status);
                status = new Status();
            }
            rdr.Close();
            conn.Close();

            return listaStatus;
        }

        /// <summary>
        /// Funkcja dodaje nowy uprawnienie do tabeli "Uprawnienie" w bazie danych 
        /// </summary>
        /// <param name="uprawnienie">Obiekt Uprawnienie</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajUprawnienie(Uprawnienie uprawnienie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_uprawnienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = uprawnienie.Nazwa;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Uprawnienie z bazy danych na postawie id_uprawnienia
        /// </summary>
        /// <param name="iduprawnienie">Id uprawnienie to usnięcia</param>
        public void usunUprawnienie(int iduprawnienie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_uprawnienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_uprawnienia";
            param.Value = iduprawnienie;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Uprawnienie w bazie danych
        /// </summary>
        /// <param name="uprawnienie">Obiekt uprawnienie zawierający inforamacje do aktualizacji</param>
        public void aktualizujUprawnienie(Uprawnienie uprawnienie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_uprawnienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_uprawnienia";
            param.Value = uprawnienie.Id_uprawnienia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = uprawnienie.Nazwa;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera uprawnienie na podstawie id uprawnienie
        /// </summary>
        /// <param name="iduprawnienie">Id uprawnienie</param>
        /// <returns>Obiekt Uprawnienie</returns>
        public Uprawnienie pobierzUprawnienie(int iduprawnienie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_uprawnienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_uprawnienia";
            param.Value = iduprawnienie;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Uprawnienie uprawnienie = new Uprawnienie();
            while (rdr.Read())
            {
                uprawnienie.Id_uprawnienia = (int)rdr["id_uprawnienia"];
                uprawnienie.Nazwa = (string)rdr["nazwa"];
            }
            rdr.Close();
            conn.Close();

            return uprawnienie;
        }

        public ObservableCollection<Uprawnienie> pobierzListeUprawnienie()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_uprawnienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            Uprawnienie uprawnienie = new Uprawnienie();
            ObservableCollection<Uprawnienie> lista = new ObservableCollection<Uprawnienie>();

            while (rdr.Read())
            {
                uprawnienie.Id_uprawnienia = (int)rdr["id_uprawnienia"];
                uprawnienie.Nazwa = (string)rdr["nazwa"];
                lista.Add(uprawnienie);
                uprawnienie = new Uprawnienie();
            }
            rdr.Close();
            conn.Close();

            return lista;

        }

        /// <summary>
        /// Funkcja dodaje nowy zdjecie do tabeli "Zdjecie" w bazie danych 
        /// </summary>
        /// <param name="zdjecie">Obiekt Zdjecie</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajZdjecie(Zdjecie zdjecie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_zdjecie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = zdjecie.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@zdjecie";
            param.Value = zdjecie.Zdjecie1;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Zdjecie z bazy danych na postawie id_zdjecia
        /// </summary>
        /// <param name="idzdjecie">Id zdjecie to usnięcia</param>
        public void usunZdjecie(int idzdjecie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_zdjecie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_zdjecia";
            param.Value = idzdjecie;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Zdjecie w bazie danych
        /// </summary>
        /// <param name="zdjecie">Obiekt zdjecie zawierający inforamacje do aktualizacji</param>
        public void aktualizujZdjecie(Zdjecie zdjecie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_zdjecie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_zdjecia";
            param.Value = zdjecie.Id_zdjecia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@zdjecie";
            param.Value = zdjecie.Zdjecie1;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = zdjecie.Nazwa;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera zdjecie na podstawie id zdjecie
        /// </summary>
        /// <param name="idzdjecie">Id zdjecie</param>
        /// <returns>Obiekt Zdjecie</returns>
        public Zdjecie pobierzZdjecie(int idzdjecie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_zdjecie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_zdjecia";
            param.Value = idzdjecie;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Zdjecie zdjecie = new Zdjecie();
            while (rdr.Read())
            {
                zdjecie.Id_zdjecia = (int)rdr["id_zdjecia"];
                zdjecie.Nazwa = (string)rdr["nazwa"];
                zdjecie.Zdjecie1 = (byte[])rdr["zdjecie"];
            }
            rdr.Close();
            conn.Close();

            return zdjecie;
        }

        public ObservableCollection<Zdjecie> pobierzListeZdjecie(int idGaleria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_zdjecie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_galeria";
            param.Value = idGaleria;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Zdjecie zdjecie = new Zdjecie();
            ObservableCollection<Zdjecie> listaZdjecie = new ObservableCollection<Zdjecie>();
            while (rdr.Read())
            {
                zdjecie.Id_zdjecia = (int)rdr["id_zdjecia"];
                zdjecie.Nazwa = (string)rdr["nazwa"];
                zdjecie.Zdjecie1 = (byte[])rdr["zdjecie"];

                listaZdjecie.Add(zdjecie);
                zdjecie = new Zdjecie();
            }
            rdr.Close();
            conn.Close();

            return listaZdjecie;
        }

        /// <summary>
        /// Funkcja dodaje nowy klient_oferta do tabeli "Klient_Oferta" w bazie danych 
        /// </summary>
        /// <param name="klient_oferta">Obiekt Klient_Oferta</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public void dodajKlient_Oferta(Klient_Oferta klient_oferta)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_klient_oferta";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_klient";
            param.Value = klient_oferta.Id_klient;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_oferta";
            param.Value = klient_oferta.Id_oferta;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@status";
            param.Value = klient_oferta.Status;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();
           
        }

        /// <summary>
        /// Funkcja usuwająca Klient_Oferta z bazy danych na postawie id_klient_ofertau
        /// </summary>
        /// <param name="idklient_oferta">Id klient_oferta to usnięcia</param>
        public void usunKlient_Oferta(int idklient_oferta)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_klient_oferta";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_klient_oferta";
            param.Value = idklient_oferta;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Klient_Oferta w bazie danych
        /// </summary>
        /// <param name="klient_oferta">Obiekt klient_oferta zawierający inforamacje do aktualizacji</param>
        public void aktualizujKlient_Oferta(Klient_Oferta klient_oferta)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_klient_oferta";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_klient";
            param.Value = klient_oferta.Id_klient;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_oferta";
            param.Value = klient_oferta.Id_oferta;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@status";
            param.Value = klient_oferta.Status;
            cmd.Parameters.Add(param);
            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera klient_oferta na podstawie id klient_oferta
        /// </summary>
        /// <param name="idklient_oferta">Id klient_oferta</param>
        /// <returns>Obiekt Klient_Oferta</returns>
        public Klient_Oferta pobierzKlient_Oferta(int idklient_oferta)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_klient_oferta";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_klient_oferta";
            param.Value = idklient_oferta;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Klient_Oferta klient_oferta = new Klient_Oferta();
            while (rdr.Read())
            {
                klient_oferta.Id_klient = (int)rdr["id_klient"];
                klient_oferta.Id_oferta = (int)rdr["id_oferta"];
                klient_oferta.Status = (string)rdr["status"];
            }
            rdr.Close();
            conn.Close();

            return klient_oferta;
        }

        /// <summary>
        /// Funkcja dodaje nowy galeria_zdjecie do tabeli "Galeria_Zdjecie" w bazie danych 
        /// </summary>
        /// <param name="galeria_zdjecie">Obiekt Galeria_Zdjecie</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajGaleria_Zdjecia(Galeria_Zdjecia galeria_zdjecie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_galeria_zdjecia";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_galeria";
            param.Value = galeria_zdjecie.Id_galeria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_zdjecia";
            param.Value = galeria_zdjecie.Id_zdjecia;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Galeria_Zdjecie z bazy danych na postawie id_galeria_zdjecieu
        /// </summary>
        /// <param name="idgaleria_zdjecie">Id galeria_zdjecie to usnięcia</param>
        public void usunGaleria_Zdjecia(int idgaleria)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_galeria_zdjecia";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_galeria";
            param.Value = idgaleria;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Galeria_Zdjecie w bazie danych
        /// </summary>
        /// <param name="galeria_zdjecie">Obiekt galeria_zdjecie zawierający inforamacje do aktualizacji</param>
        public void aktualizujGaleria_Zdjecia(Galeria_Zdjecia galeria_zdjecie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_galeria_zdjecia";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_galeria";
            param.Value = galeria_zdjecie.Id_galeria;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_zdjecie";
            param.Value = galeria_zdjecie.Id_zdjecia;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera galeria_zdjecie na podstawie id galeria_zdjecie
        /// </summary>
        /// <param name="idgaleria_zdjecie">Id galeria_zdjecie</param>
        /// <returns>Obiekt Galeria_Zdjecie</returns>
        public Galeria_Zdjecia pobierzGaleria_Zdjecia(int idgaleria_zdjecie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_galeria_zdjecia";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_galeria";
            param.Value = idgaleria_zdjecie;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_zdjecia";
            param.Value = idgaleria_zdjecie;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Galeria_Zdjecia galeria_zdjecie = new Galeria_Zdjecia();
            while (rdr.Read())
            {
                galeria_zdjecie.Id_galeria = (int)rdr["id_galeria"];
                galeria_zdjecie.Id_zdjecia = (int)rdr["id_zdjecia"];
            }
            rdr.Close();
            conn.Close();

            return galeria_zdjecie;
        }

        /// <summary>
        /// Funkcja dodaje nowy klient do tabeli "Pracownicy" w bazie danych 
        /// </summary>
        /// <param name="klient">Obiekt Klient</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajKlient(Klient klient)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_klient";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param = provider.CreateParameter();
            param.ParameterName = "@imie";
            param.Value = klient.Imie;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwisko";
            param.Value = klient.Nazwisko;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@plec";
            param.Value = klient.Plec;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nr_dowodu";
            param.Value = klient.Nr_dowodu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@tel_stacjonarny";
            param.Value = klient.Tel_stacjonarny;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@tel_komorkowy";
            param.Value = klient.Tel_komorkowy;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_adres";
            param.Value = klient.Id_adres;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_status";
            param.Value = klient.Id_status;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@zezwolenieSMS";
            param.Value = klient.ZezwolenieSMS;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@zezwolenieEMAIL";
            param.Value = klient.ZezwolenieEMAIL;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@email";
            param.Value = klient.Email;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_urodzenia";
            param.Value = klient.Data_urodzenia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@pesel";
            param.Value = klient.Pesel;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nr_paszport";
            param.Value = klient.Nr_paszportu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@wydanie_paszportu";
            param.Value = klient.Wydanie_paszportu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@klient_nadrzedny";
            param.Value = klient.Klient_nadrzedny;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Klient z bazy danych na postawie id_klient
        /// </summary>
        /// <param name="idklient">Id klient to usnięcia</param>
        public void usunKlient(int idklient)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_klient";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_klient";
            param.Value = idklient;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Klient w bazie danych
        /// </summary>
        /// <param name="klient">Obiekt klient zawierający inforamacje do aktualizacji</param>
        public void aktualizujKlient(Klient klient)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_klient";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_klient";
            param.Value = klient.Id_klient;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@imie";
            param.Value = klient.Imie;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwisko";
            param.Value = klient.Nazwisko;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@plec";
            param.Value = klient.Plec;
            cmd.Parameters.Add(param);
            
            param = provider.CreateParameter();
            param.ParameterName = "@nr_dowodu";
            param.Value = klient.Nr_dowodu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@tel_stacjonarny";
            param.Value = klient.Tel_stacjonarny;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@tel_komorkowy";
            param.Value = klient.Tel_komorkowy;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_adres";
            param.Value = klient.Id_adres;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_status";
            param.Value = klient.Id_status;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@zezwolenieSMS";
            param.Value = klient.ZezwolenieSMS;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@zezwolenieEMAIL";
            param.Value = klient.ZezwolenieEMAIL;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@email";
            param.Value = klient.Email;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_urodzenia";
            param.Value = klient.Data_urodzenia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@pesel";
            param.Value = klient.Pesel;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nr_paszport";
            param.Value = klient.Nr_paszportu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@wydanie_paszportu";
            param.Value = klient.Wydanie_paszportu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@klient_nadrzedny";
            param.Value = klient.Klient_nadrzedny;
            cmd.Parameters.Add(param);





            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera klient na podstawie id klient
        /// </summary>
        /// <param name="idklient">Id klient</param>
        /// <returns>Obiekt Klient</returns>
        public Klient pobierzKlient(int idklient)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_klient";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_klient";
            param.Value = idklient;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Klient klient = new Klient();
            while (rdr.Read())
            {
                klient.Id_klient = (int)rdr["id_klient"];
                klient.Imie = (string)rdr["imie"];
                klient.Nazwisko = (string)rdr["nazwisko"];
                klient.Plec = (string)rdr["plec"];
                klient.Nr_dowodu = (string)rdr["nr_dowodu"];
                klient.Tel_stacjonarny = (string)rdr["tel_stacjonarny"];
                klient.Tel_komorkowy = (string)rdr["tel_komorkowy"];             
                klient.Id_adres = (int)rdr["id_adres"];
                klient.Id_status = (int)rdr["id_status"];
                klient.ZezwolenieSMS = (bool)rdr["zezwolenieSMS"];
                klient.ZezwolenieEMAIL = (bool)rdr["zezwolenieEMAIL"];
                klient.Email = (string)rdr["email"];             
                klient.Data_urodzenia = (DateTime)rdr["data_urodzenia"];
                klient.Pesel = (string)rdr["pesel"];
                klient.Nr_paszportu = (string)rdr["nr_paszport"];
                klient.Wydanie_paszportu = (DateTime)rdr["wydanie_paszportu"];
                klient.Klient_nadrzedny = (int)rdr["klient_nadrzedny"];
            }
            rdr.Close();
            conn.Close();

            return klient;
        }

        /// <summary>
        /// Funkcja zwraca obiekt KlientAdres który powstał z połączenia tabel Klient i Adres
        /// </summary>
        /// <param name="id">Id użytkownika, którego dane funkcja ma zwrócić</param>
        /// <returns>Obiekt KlientAdres w którym znajdują się informacje o użytkowniku</returns>
        public KlientAdres pobierzKlientaPoId(int id)
        {
            KlientAdres klientAdres = new KlientAdres();
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;

            //otawarcie połączenia
            conn.Open();

            //wywoływanie procedury składowanej
            cmd.CommandText = "pobierz_dane_klienta";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury
            param.ParameterName = "@id_klient";
            param.Value = id;

            cmd.Parameters.Add(param);
            
            DbDataReader rdr = cmd.ExecuteReader();

            while (rdr.Read())
            {
                //część z tabeli Klient
                klientAdres.Id_klient = (int)rdr["id_klient"];
                klientAdres.Imie = (string)rdr["imie"];
                klientAdres.Nazwisko = (string)rdr["nazwisko"];
                klientAdres.Plec = (string)rdr["plec"];
                klientAdres.Nr_dowodu = (string)rdr["nr_dowodu"];
                klientAdres.Tel_stacjonarny = (string)rdr["tel_stacjonarny"];
                klientAdres.Tel_komorkowy = (string)rdr["tel_komorkowy"];
                klientAdres.Id_adres = (int)rdr["id_adres"];
                klientAdres.ZezwolenieSMS = (bool)rdr["zezwolenieSMS"];
                klientAdres.ZezwolenieEMAIL = (bool)rdr["zezwolenieEMAIL"];
                klientAdres.Email = (string)rdr["email"];
                klientAdres.Data_urodzenia = (DateTime)rdr["data_urodzenia"];
                klientAdres.Pesel = (string)rdr["pesel"];
                klientAdres.Nr_paszportu = (string)rdr["nr_paszport"];
                klientAdres.Wydanie_paszportu = (DateTime)rdr["wydanie_paszportu"];
                klientAdres.Klient_nadrzedny = (int)rdr["klient_nadrzedny"];

                //część z tabeli Adres
                klientAdres.Ulica = (string)rdr["ulica"];
                klientAdres.Nr_domu = (string)rdr["nr_domu"];
                klientAdres.Kod_pocztowy = (string)rdr["kod_pocztowy"];
                klientAdres.Wojewodztwo = (string)rdr["wojewodztwo"];
                klientAdres.Kraj = (string)rdr["kraj"];
                klientAdres.Miasto = (string)rdr["miasto"];
                
               
            }
            conn.Close();
            return klientAdres;
        }

        public ObservableCollection<KlientUslugi> pobierzUslugiKlient(int idklient)
        {
            KlientUslugi klientUslugi = new KlientUslugi();
            ObservableCollection<KlientUslugi> listaUslug = new ObservableCollection<KlientUslugi>();
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_uslugi_klienta";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_klient";
            param.Value = idklient;

            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            while (rdr.Read())
            {
                klientUslugi.Id_klient = (int)rdr["id_klient"];
                klientUslugi.Id_rezerwacja = (int)rdr["id_rezerwacja"];
                klientUslugi.Id_oferta = (int)rdr["id_oferta"];
                klientUslugi.Id_termin = (int)rdr["id_termin"];

                listaUslug.Add(klientUslugi);
                klientUslugi = new KlientUslugi();

            }
            return listaUslug;

        }

        /// <summary>
        /// Funkcja zwraca listę klientów o podanym w parametrze idstatus
        /// Statusy są określone w tabeli "Status" 
        /// </summary>
        /// <param name="idstatus">Id statusu klienta np. 1 to "Rezerwujący"</param>
        /// <returns>Zwracana jest lista klientow o podanym statusie</returns>
        public ObservableCollection<Klient> pobierzListeKlientow(int idstatus=0)
        {
            Klient klient = new Klient();
            ObservableCollection<Klient> listaKlient = new ObservableCollection<Klient>();
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;

            //otawarcie połączenia
            conn.Open();

            //wywołanie procedury składowanej
            cmd.CommandText = "pobierz_liste_klientow";
            cmd.CommandType = CommandType.StoredProcedure;
            
            // Jezlie 0 to zwróć wszystkie wartości
            if (idstatus > 0)
            {
                DbParameter param = provider.CreateParameter();
                param.ParameterName = "@id_status";
                param.Value = idstatus;
                cmd.Parameters.Add(param);
            }

            
            DbDataReader rdr = cmd.ExecuteReader();

            while (rdr.Read())
            {
                
                klient.Id_klient = (int)rdr["id_klient"];
                klient.Imie = (string)rdr["imie"];
                klient.Nazwisko = (string)rdr["nazwisko"];
                klient.Plec = (string)rdr["plec"];
                klient.Nr_dowodu = (string)rdr["nr_dowodu"];
                klient.Tel_stacjonarny = (string)rdr["tel_stacjonarny"];
                klient.Tel_komorkowy = (string)rdr["tel_komorkowy"];
                klient.ZezwolenieSMS = (bool)rdr["zezwolenieSMS"];
                klient.ZezwolenieEMAIL = (bool)rdr["zezwolenieEMAIL"];
                klient.Email = (string)rdr["email"];
                klient.Id_adres = (int)rdr["id_adres"];
                klient.Id_status = (int)rdr["id_status"];
                klient.Data_urodzenia = (DateTime)rdr["data_urodzenia"];
                klient.Pesel = (string)rdr["pesel"];
                klient.Nr_paszportu = (string)rdr["nr_paszport"];
                klient.Wydanie_paszportu = (DateTime)rdr["wydanie_paszportu"];
                klient.Klient_nadrzedny = (int)rdr["klient_nadrzedny"];


                // Dodawanie klienta do listy klientów
                listaKlient.Add(klient);

                //tworzenie nowego obiektu
                klient = new Klient();

            }
            rdr.Close();
            conn.Close();

            return listaKlient;
        }

        public ObservableCollection<Klient> pobierzListeKlientowEmail()
        {
            Klient klient = new Klient();
            ObservableCollection<Klient> listaKlient = new ObservableCollection<Klient>();
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;

            //otawarcie połączenia
            conn.Open();

            //wywołanie procedury składowanej
            cmd.CommandText = "pobierz_liste_klientow";
            cmd.CommandType = CommandType.StoredProcedure;

            // Jezlie 0 to zwróć wszystkie wartości     
      
            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@czy_email";
            param.Value = 1;
            cmd.Parameters.Add(param);



            DbDataReader rdr = cmd.ExecuteReader();

            while (rdr.Read())
            {
                klient.Id_klient = (int)rdr["id_klient"];
                klient.Imie = (string)rdr["imie"];
                klient.Nazwisko = (string)rdr["nazwisko"];
                klient.Plec = (string)rdr["plec"];
                klient.Nr_dowodu = (string)rdr["nr_dowodu"];
                klient.Tel_stacjonarny = (string)rdr["tel_stacjonarny"];
                klient.Tel_komorkowy = (string)rdr["tel_komorkowy"];
                klient.ZezwolenieSMS = (bool)rdr["zezwolenieSMS"];
                klient.ZezwolenieEMAIL = (bool)rdr["zezwolenieEMAIL"];
                klient.Email = (string)rdr["email"];
                klient.Id_adres = (int)rdr["id_adres"];
                klient.Id_status = (int)rdr["id_status"];
                klient.Data_urodzenia = (DateTime)rdr["data_urodzenia"];
                klient.Pesel = (string)rdr["pesel"];
                klient.Nr_paszportu = (string)rdr["nr_paszport"];
                klient.Wydanie_paszportu = (DateTime)rdr["wydanie_paszportu"];
                klient.Klient_nadrzedny = (int)rdr["klient_nadrzedny"];


                // Dodawanie klienta do listy klientów
                listaKlient.Add(klient);

                //tworzenie nowego obiektu
                klient = new Klient();

            }
            rdr.Close();
            conn.Close();

            return listaKlient;
        }

        public ObservableCollection<Klient> pobierzListeKlientowSMS()
        {
            Klient klient = new Klient();
            ObservableCollection<Klient> listaKlient = new ObservableCollection<Klient>();
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;

            //otawarcie połączenia
            conn.Open();

            //wywołanie procedury składowanej
            cmd.CommandText = "pobierz_liste_klientow";
            cmd.CommandType = CommandType.StoredProcedure;

            // Jezlie 0 to zwróć wszystkie wartości     

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@czy_sms";
            param.Value = 1;
            cmd.Parameters.Add(param);



            DbDataReader rdr = cmd.ExecuteReader();

            while (rdr.Read())
            {
                klient.Id_klient = (int)rdr["id_klient"];
                klient.Imie = (string)rdr["imie"];
                klient.Nazwisko = (string)rdr["nazwisko"];
                klient.Plec = (string)rdr["plec"];
                klient.Nr_dowodu = (string)rdr["nr_dowodu"];
                klient.Tel_stacjonarny = (string)rdr["tel_stacjonarny"];
                klient.Tel_komorkowy = (string)rdr["tel_komorkowy"];
                klient.ZezwolenieSMS = (bool)rdr["zezwolenieSMS"];
                klient.ZezwolenieEMAIL = (bool)rdr["zezwolenieEMAIL"];
                klient.Email = (string)rdr["email"];
                klient.Id_adres = (int)rdr["id_adres"];
                klient.Id_status = (int)rdr["id_status"];
                klient.Data_urodzenia = (DateTime)rdr["data_urodzenia"];
                klient.Pesel = (string)rdr["pesel"];
                klient.Nr_paszportu = (string)rdr["nr_paszport"];
                klient.Wydanie_paszportu = (DateTime)rdr["wydanie_paszportu"];
                klient.Klient_nadrzedny = (int)rdr["klient_nadrzedny"];


                // Dodawanie klienta do listy klientów
                listaKlient.Add(klient);

                //tworzenie nowego obiektu
                klient = new Klient();

            }
            rdr.Close();
            conn.Close();

            return listaKlient;
        }

        /// <summary>
        /// Funkcja dodaje nowy termin do tabeli "Termin" w bazie danych 
        /// </summary>
        /// <param name="termin">Obiekt Termin</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajTermin(Termin termin)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_termin";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param = provider.CreateParameter();
            param.ParameterName = "@id_oferta";
            param.Value = termin.Id_oferta;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_rozpoczecia";
            param.Value = termin.Data_rozpoczecia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_zakonczenia";
            param.Value = termin.Data_zakonczenia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@ilosc_dni";
            param.Value = termin.Ilosc_dni;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena";
            param.Value = termin.Cena;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_miasta_wylotu";
            param.Value = termin.Id_miasta_wylotu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_miasta_celu";
            param.Value = termin.Id_miasta_celu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@godzina_wylotu_z_celu";
            param.Value = termin.Godzina_wylotu_z_celu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@godzina_wylotu";
            param.Value = termin.Godzina_wylotu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@czas_lotu";
            param.Value = termin.Czas_lotu;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Termin z bazy danych na postawie id_termin
        /// </summary>
        /// <param name="idtermin">Id termin to usnięcia</param>
        public void usunTermin(int idtermin)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_termin";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_termin";
            param.Value = idtermin;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Termin w bazie danych
        /// </summary>
        /// <param name="termin">Obiekt termin zawierający inforamacje do aktualizacji</param>
        public void aktualizujTermin(Termin termin)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_termin";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_termin";
            param.Value = termin.Id_termin;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_oferta";
            param.Value = termin.Id_oferta;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_rozpoczecia";
            param.Value = termin.Data_rozpoczecia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_zakonczenia";
            param.Value = termin.Data_zakonczenia;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@ilosc_dni";
            param.Value = termin.Ilosc_dni;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena";
            param.Value = termin.Cena;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_miasta_wylotu";
            param.Value = termin.Id_miasta_wylotu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_miasta_celu";
            param.Value = termin.Id_miasta_celu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@godzina_wylotu_z_celu";
            param.Value = termin.Godzina_wylotu_z_celu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@godzina_wylotu";
            param.Value = termin.Godzina_wylotu;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@czas_lotu";
            param.Value = termin.Czas_lotu;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera termin na podstawie id termin
        /// </summary>
        /// <param name="idtermin">Id termin</param>
        /// <returns>Obiekt Termin</returns>
        public Termin pobierzTermin(int idtermin)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_termin";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_termin";
            param.Value = idtermin;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Termin termin = new Termin();
            while (rdr.Read())
            {
                termin.Id_termin = (int)rdr["id_termin"];
                termin.Id_oferta = (int)rdr["id_oferta"];
                termin.Data_rozpoczecia = (DateTime)rdr["data_rozpoczecia"];
                termin.Ilosc_dni = (int)rdr["ilosc_dni"];
                termin.Cena = (Decimal)rdr["cena"];
                termin.Id_miasta_wylotu = (int)rdr["id_miasta_wylotu"];
                termin.Id_miasta_celu = (int)rdr["id_miasta_celu"];
                termin.Godzina_wylotu_z_celu = (DateTime)rdr["godzina_wylotu_z_celu"];
                termin.Godzina_wylotu = (DateTime)rdr["godzina_wylotu"];
                termin.Czas_lotu = Convert.ToInt64(rdr["czas_lotu"]);
                termin.Data_zakonczenia = (DateTime)rdr["data_zakonczenia"];
            }
            rdr.Close();
            conn.Close();

            return termin;
        }

        /// <summary>
        /// Funkcja zwracająca listę terminów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<Termin> pobierzListeTermin(int idoferta=0)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_termin";
            cmd.CommandType = CommandType.StoredProcedure;

            if (idoferta > 0)
            {
                DbParameter param = provider.CreateParameter();
                param.ParameterName = "@id_oferta";
                param.Value = idoferta;
                cmd.Parameters.Add(param);                
            }

            DbDataReader rdr = cmd.ExecuteReader();

            Termin termin = new Termin();
            ObservableCollection<Termin> listaTerminow = new ObservableCollection<Termin>();
            while (rdr.Read())
            {

                termin.Id_termin = (int)rdr["id_termin"];
                termin.Id_oferta = (int)rdr["id_oferta"];
                termin.Data_rozpoczecia = (DateTime)rdr["data_rozpoczecia"];
                termin.Ilosc_dni = (int)rdr["ilosc_dni"];
                termin.Cena = (Decimal)rdr["cena"];
                termin.Id_miasta_wylotu = (int)rdr["id_miasta_wylotu"];
                termin.Id_miasta_celu = (int)rdr["id_miasta_celu"];
                termin.Godzina_wylotu_z_celu = (DateTime)rdr["godzina_wylotu_z_celu"];
                termin.Godzina_wylotu = (DateTime)rdr["godzina_wylotu"];
                termin.Czas_lotu = Convert.ToInt64(rdr["czas_lotu"]);
                termin.Data_zakonczenia = (DateTime)rdr["data_zakonczenia"];

                listaTerminow.Add(termin);
                termin = new Termin();
            }
            rdr.Close();
            conn.Close();

            return listaTerminow;
        }

        public ObservableCollection<Termin> pobierzListeTerminHotel(int idhotel)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_termin_hotel";
            cmd.CommandType = CommandType.StoredProcedure;

            
            
            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_hotel";
            param.Value = idhotel;
            cmd.Parameters.Add(param);
            

            DbDataReader rdr = cmd.ExecuteReader();

            Termin termin = new Termin();
            ObservableCollection<Termin> listaTerminow = new ObservableCollection<Termin>();
            while (rdr.Read())
            {

                termin.Id_termin = (int)rdr["id_termin"];
                termin.Id_oferta = (int)rdr["id_oferta"];
                termin.Data_rozpoczecia = (DateTime)rdr["data_rozpoczecia"];
                termin.Ilosc_dni = (int)rdr["ilosc_dni"];
                termin.Cena = (Decimal)rdr["cena"];
                termin.Id_miasta_wylotu = (int)rdr["id_miasta_wylotu"];
                termin.Id_miasta_celu = (int)rdr["id_miasta_celu"];
                termin.Godzina_wylotu_z_celu = (DateTime)rdr["godzina_wylotu_z_celu"];
                termin.Godzina_wylotu = (DateTime)rdr["godzina_wylotu"];
                termin.Czas_lotu = Convert.ToInt64(rdr["czas_lotu"]);
                termin.Data_zakonczenia = (DateTime)rdr["data_zakonczenia"];

                listaTerminow.Add(termin);
                termin = new Termin();
            }
            rdr.Close();
            conn.Close();

            return listaTerminow;
        }

        /// <summary>
        /// Funkcja dodaje nowy rezerwacja do tabeli "Rezerwacja" w bazie danych 
        /// </summary>
        /// <param name="rezerwacja">Obiekt Rezerwacja</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajRezerwacja(Rezerwacja rezerwacja)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury


            param.ParameterName = "@id_termin";
            param.Value = rezerwacja.Id_termin;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@wartosc";
            param.Value = rezerwacja.Wartosc;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@ilosc_doroslych";
            param.Value = rezerwacja.Ilosc_doroslych;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@ilosc_dzieci";
            param.Value = rezerwacja.Ilosc_dzieci;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@numer_rezerwacji";
            param.Value = rezerwacja.Numer_rezerwacji;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@status";
            param.Value = rezerwacja.Status;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@dodatkowe_uslugi";
            param.Value = rezerwacja.Dodatkowe_uslugi;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena_dodatkowe";
            param.Value = rezerwacja.Cena_dodatkowe;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_oddzial";
            param.Value = rezerwacja.Id_oddzial;
            cmd.Parameters.Add(param);




            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Rezerwacja z bazy danych na postawie id_rezerwacja
        /// </summary>
        /// <param name="idrezerwacja">Id rezerwacja to usnięcia</param>
        public void usunRezerwacja(int idrezerwacja)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_rezerwacja";
            param.Value = idrezerwacja;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }



        /// <summary>
        /// Funkcja akutualizująca Rezerwacja w bazie danych
        /// </summary>
        /// <param name="rezerwacja">Obiekt rezerwacja zawierający inforamacje do aktualizacji</param>
        public void aktualizujRezerwacja(Rezerwacja rezerwacja)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_rezerwacja";
            param.Value = rezerwacja.Id_rezerwacja;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_termin";
            param.Value = rezerwacja.Id_termin;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@wartosc";
            param.Value = rezerwacja.Wartosc;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@ilosc_doroslych";
            param.Value = rezerwacja.Ilosc_doroslych;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@ilosc_dzieci";
            param.Value = rezerwacja.Ilosc_dzieci;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@numer_rezerwacji";
            param.Value = rezerwacja.Numer_rezerwacji;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@status";
            param.Value = rezerwacja.Status;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@dodatkowe_uslugi";
            param.Value = rezerwacja.Dodatkowe_uslugi;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cena_dodatkowe";
            param.Value = rezerwacja.Cena_dodatkowe;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_oddzial";
            param.Value = rezerwacja.Id_oddzial;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera rezerwacja na podstawie id rezerwacja
        /// </summary>
        /// <param name="idrezerwacja">Id rezerwacja</param>
        /// <returns>Obiekt Rezerwacja</returns>
        public Rezerwacja pobierzRezerwacja(int idrezerwacja)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_rezerwacja";
            param.Value = idrezerwacja;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Rezerwacja rezerwacja = new Rezerwacja();
            while (rdr.Read())
            {
                rezerwacja.Id_rezerwacja = (int)rdr["id_rezerwacja"];
                rezerwacja.Id_termin = (int)rdr["id_termin"];
                rezerwacja.Wartosc = (Decimal)rdr["wartosc"];
                rezerwacja.Ilosc_doroslych = (int)rdr["ilosc_doroslych"];
                rezerwacja.Ilosc_dzieci = (int)rdr["ilosc_dzieci"];
                rezerwacja.Numer_rezerwacji = (string)rdr["numer_rezerwacji"];
                rezerwacja.Id_klient = (int)rdr["id_klient"];
                rezerwacja.Status = (string)rdr["status"];
                rezerwacja.Dodatkowe_uslugi = (string)rdr["dodatkowe_uslugi"];
                rezerwacja.Cena_dodatkowe = (decimal)rdr["cena_dodatkowe"];
                rezerwacja.Id_oddzial = (int)rdr["id_oddzial"];
            }
            rdr.Close(); 
            conn.Close();

            return rezerwacja;
        }

        /// <summary>
        /// Funkcja zwracająca listę rezerwacjaów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<Rezerwacja> pobierzListeRezerwacja(int idtermin=0)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            
            // Jezeli idtermin jest rózny od zera to znaczy zeby funkcja zwrociła rezerwacje tylko podanego terminu
            if (idtermin > 0)
            {
                DbParameter param = provider.CreateParameter();
                param.ParameterName = "@id_termin";
                param.Value = idtermin;
                cmd.Parameters.Add(param);
            }

            DbDataReader rdr = cmd.ExecuteReader();

            Rezerwacja rezerwacja = new Rezerwacja();
            ObservableCollection<Rezerwacja> listaRezerwacjaow = new ObservableCollection<Rezerwacja>();
            while (rdr.Read())
            {

                rezerwacja.Id_rezerwacja = (int)rdr["id_rezerwacja"];
                rezerwacja.Id_termin = (int)rdr["id_termin"];
                rezerwacja.Wartosc = (Decimal)rdr["wartosc"];
                rezerwacja.Ilosc_doroslych = (int)rdr["ilosc_doroslych"];
                rezerwacja.Ilosc_dzieci = (int)rdr["ilosc_dzieci"];
                rezerwacja.Id_klient = (int)rdr["id_klient"];
                rezerwacja.Numer_rezerwacji = (string)rdr["numer_rezerwacji"];
                rezerwacja.Status = (string)rdr["status"];
                rezerwacja.Dodatkowe_uslugi = (string)rdr["dodatkowe_uslugi"];
                rezerwacja.Cena_dodatkowe = (decimal)rdr["cena_dodatkowe"];
                rezerwacja.Id_oddzial = (int)rdr["id_oddzial"];

                listaRezerwacjaow.Add(rezerwacja);
                rezerwacja = new Rezerwacja();
            }
            rdr.Close();
            conn.Close();

            return listaRezerwacjaow;
        }

        /// <summary>
        /// Funkcja dodaje nowy wyzywienie do tabeli "Wyzywienie" w bazie danych 
        /// </summary>
        /// <param name="wyzywienie">Obiekt Wyzywienie</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajWyzywienie(Wyzywienie wyzywienie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_wyzywienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = wyzywienie.Nazwa;
            cmd.Parameters.Add(param);
           

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Wyzywienie z bazy danych na postawie id_wyzywienie
        /// </summary>
        /// <param name="idwyzywienie">Id wyzywienie to usnięcia</param>
        public void usunWyzywienie(int idwyzywienie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_wyzywienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_wyzywienie";
            param.Value = idwyzywienie;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Wyzywienie w bazie danych
        /// </summary>
        /// <param name="wyzywienie">Obiekt wyzywienie zawierający inforamacje do aktualizacji</param>
        public void aktualizujWyzywienie(Wyzywienie wyzywienie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_wyzywienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_wyzywienie";
            param.Value = wyzywienie.Id_wyzywienie;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = wyzywienie.Nazwa;
            cmd.Parameters.Add(param);
           
            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera wyzywienie na podstawie id wyzywienie
        /// </summary>
        /// <param name="idwyzywienie">Id wyzywienie</param>
        /// <returns>Obiekt Wyzywienie</returns>
        public Wyzywienie pobierzWyzywienie(int idwyzywienie)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_wyzywienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_wyzywienie";
            param.Value = idwyzywienie;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Wyzywienie wyzywienie = new Wyzywienie();
            while (rdr.Read())
            {
                wyzywienie.Id_wyzywienie = (int)rdr["id_wyzywienie"];
                wyzywienie.Nazwa = (string)rdr["nazwa"];
            
            }
            rdr.Close();
            conn.Close();

            return wyzywienie;
        }

        /// <summary>
        /// Funkcja zwracająca listę wyzywienieów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<Wyzywienie> pobierzListeWyzywienie()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_wyzywienie";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            Wyzywienie wyzywienie = new Wyzywienie();
            ObservableCollection<Wyzywienie> listaWyzywienieow = new ObservableCollection<Wyzywienie>();
            while (rdr.Read())
            {

                wyzywienie.Id_wyzywienie = (int)rdr["id_wyzywienie"];
                wyzywienie.Nazwa = (string)rdr["nazwa"];              

                listaWyzywienieow.Add(wyzywienie);
                wyzywienie = new Wyzywienie();
            }
            rdr.Close();
            conn.Close();

            return listaWyzywienieow;
        }

        /// <summary>
        /// Funkcja dodaje nowy linielotnicze do tabeli "LinieLotnicze" w bazie danych 
        /// </summary>
        /// <param name="linielotnicze">Obiekt LinieLotnicze</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajLinieLotnicze(LinieLotnicze linielotnicze)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_linielotnicze";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = linielotnicze.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = linielotnicze.Opis;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca LinieLotnicze z bazy danych na postawie id_linielotnicze
        /// </summary>
        /// <param name="idlinielotnicze">Id linielotnicze to usnięcia</param>
        public void usunLinieLotnicze(int idlinielotnicze)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_linielotnicze";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_linielotnicze";
            param.Value = idlinielotnicze;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca LinieLotnicze w bazie danych
        /// </summary>
        /// <param name="linielotnicze">Obiekt linielotnicze zawierający inforamacje do aktualizacji</param>
        public void aktualizujLinieLotnicze(LinieLotnicze linielotnicze)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_linielotnicze";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_linielotnicze";
            param.Value = linielotnicze.Id_linielotnicze;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = linielotnicze.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = linielotnicze.Opis;
            cmd.Parameters.Add(param);

            

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera linielotnicze na podstawie id linielotnicze
        /// </summary>
        /// <param name="idlinielotnicze">Id linielotnicze</param>
        /// <returns>Obiekt LinieLotnicze</returns>
        public LinieLotnicze pobierzLinieLotnicze(int idlinielotnicze)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_linielotnicze";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_linielotnicze";
            param.Value = idlinielotnicze;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            LinieLotnicze linielotnicze = new LinieLotnicze();
            while (rdr.Read())
            {
                linielotnicze.Id_linielotnicze = (int)rdr["id_linielotnicze"];
                linielotnicze.Nazwa = (string)rdr["nazwa"];
                linielotnicze.Opis = (string)rdr["opis"];
            }
            rdr.Close();
            conn.Close();

            return linielotnicze;
        }

        /// <summary>
        /// Funkcja zwracająca listę linielotniczeów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<LinieLotnicze> pobierzListeLinieLotnicze()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_linielotnicze";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            LinieLotnicze linielotnicze = new LinieLotnicze();
            ObservableCollection<LinieLotnicze> listaLinieLotniczeow = new ObservableCollection<LinieLotnicze>();
            while (rdr.Read())
            {

                linielotnicze.Id_linielotnicze = (int)rdr["id_linielotnicze"];
                linielotnicze.Nazwa = (string)rdr["nazwa"];
                linielotnicze.Opis = (string)rdr["opis"];
    
                listaLinieLotniczeow.Add(linielotnicze);
                linielotnicze = new LinieLotnicze();
            }
            rdr.Close();
            conn.Close();

            return listaLinieLotniczeow;
        }

        /// <summary>
        /// Funkcja dodaje nowy klient do tabeli "Klient_Rezerwacja" w bazie danych 
        /// </summary>
        /// <param name="klient">Obiekt Klient_Rezerwacja</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajKlient_Rezerwacja(Klient_Rezerwacja klient)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_klient_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_klient";
            param.Value = klient.Id_klient;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_rezerwacja";
            param.Value = klient.Id_rezerwacja;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_status";
            param.Value = klient.Id_status;
            cmd.Parameters.Add(param);
            cmd.ExecuteNonQuery();
            int indeksDodanegoWiersza = 0;// Convert.ToInt32();
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Klient_Rezerwacja z bazy danych na postawie id_klient
        /// </summary>
        /// <param name="idklient">Id klient to usnięcia</param>
        public void usunKlient_Rezerwacja(int idklient)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_klient_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_klient";
            param.Value = idklient;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja usuwająca Klient_Rezerwacja z bazy danych na postawie id_klient
        /// </summary>
        /// <param name="idklient">Id klient to usnięcia</param>
        public void usunKlient_RezerwacjaPoIdRezerwacji(int idrezerwacja)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_klient_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_rezerwacja";
            param.Value = idrezerwacja;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Klient_Rezerwacja w bazie danych
        /// </summary>
        /// <param name="klient">Obiekt klient zawierający inforamacje do aktualizacji</param>
        public void aktualizujKlient_Rezerwacja(Klient_Rezerwacja klient)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_klient_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_klient";
            param.Value = klient.Id_klient;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_rezerwacja";
            param.Value = klient.Id_rezerwacja;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@id_status";
            param.Value = klient.Id_status;
            cmd.Parameters.Add(param);

            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera klient na podstawie id klient
        /// </summary>
        /// <param name="idklient">Id klient</param>
        /// <returns>Obiekt Klient_Rezerwacja</returns>
        public Klient_Rezerwacja pobierzKlient_Rezerwacja(int idklient)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_klient_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_klient";
            param.Value = idklient;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Klient_Rezerwacja klient = new Klient_Rezerwacja();
            while (rdr.Read())
            {
                klient.Id_klient = (int)rdr["id_klient"];
                klient.Id_rezerwacja = (int)rdr["id_rezerwacja"];
                klient.Id_status = (int)rdr["id_status"];
            }
            rdr.Close();
            conn.Close();

            return klient;
        }

        /// <summary>
        /// Funkcja zwracająca listę klientów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<Klient_Rezerwacja> pobierzListeKlient_Rezerwacja(int idrezerwacja=0)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_klient_rezerwacja";
            cmd.CommandType = CommandType.StoredProcedure;

            if (idrezerwacja > 0)
            {
                DbParameter param = provider.CreateParameter();
                param.ParameterName = "@id_rezerwacja";
                param.Value = idrezerwacja;
                cmd.Parameters.Add(param);
            }

            DbDataReader rdr = cmd.ExecuteReader();

            Klient_Rezerwacja klient = new Klient_Rezerwacja();
            ObservableCollection<Klient_Rezerwacja> listaKlient_Rezerwacja = new ObservableCollection<Klient_Rezerwacja>();
            while (rdr.Read())
            {

                klient.Id_klient = (int)rdr["id_klient"];
                klient.Id_rezerwacja = (int)rdr["id_rezerwacja"];
                klient.Id_status = (int)rdr["id_status"];

                listaKlient_Rezerwacja.Add(klient);
                klient = new Klient_Rezerwacja();
            }
            rdr.Close();
            conn.Close();

            return listaKlient_Rezerwacja;
        }

        /// <summary>
        /// Funkcja dodaje nowy uslugi do tabeli "DodatkoweUslugi" w bazie danych 
        /// </summary>
        /// <param name="uslugi">Obiekt DodatkoweUslugi</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajDodatkoweUslugi(DodatkoweUslugi uslugi)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_dodatkoweuslugi";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = uslugi.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = uslugi.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cene";
            param.Value = uslugi.Cena;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@czy_w_cenie";
            param.Value = uslugi.Czy_w_cenie;
            cmd.Parameters.Add(param);



            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca DodatkoweUslugi z bazy danych na postawie id_uslugiu
        /// </summary>
        /// <param name="iduslugi">Id uslugi to usnięcia</param>
        public void usunDodatkoweUslugi(int iduslugi)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_dodatkoweuslugi";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_uslugi";
            param.Value = iduslugi;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca DodatkoweUslugi w bazie danych
        /// </summary>
        /// <param name="uslugi">Obiekt uslugi zawierający inforamacje do aktualizacji</param>
        public void aktualizujDodatkoweUslugi(DodatkoweUslugi uslugi)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_dodatkoweuslugi";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_uslugi";
            param.Value = uslugi.Id_uslugi;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = uslugi.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = uslugi.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@cene";
            param.Value = uslugi.Cena;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@czy_w_cenie";
            param.Value = uslugi.Czy_w_cenie;
            cmd.Parameters.Add(param);




            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera uslugi na podstawie id uslugi
        /// </summary>
        /// <param name="iduslugi">Id uslugi</param>
        /// <returns>Obiekt DodatkoweUslugi</returns>
        public DodatkoweUslugi pobierzDodatkoweUslugi(int iduslugi)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_dodatkoweuslugi";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_uslugi";
            param.Value = iduslugi;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            DodatkoweUslugi uslugi = new DodatkoweUslugi();
            while (rdr.Read())
            {
                uslugi.Id_uslugi= (int)rdr["id_uslugi"];
                uslugi.Nazwa = (string)rdr["nazwa"];
                uslugi.Opis = (string)rdr["opis"];
                uslugi.Cena = (decimal)rdr["cena"];
                uslugi.Czy_w_cenie = (bool)rdr["czy_w_cenie"];
            }
            rdr.Close();
            conn.Close();

            return uslugi;
        }

        /// <summary>
        /// Funkcja zwracająca listę uslugiów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<DodatkoweUslugi> pobierzListeDodatkoweUslugi()
        {
            
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_dodatkoweuslugi";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            DodatkoweUslugi uslugi = new DodatkoweUslugi();
            ObservableCollection<DodatkoweUslugi> listaDodatkoweUslugiow = new ObservableCollection<DodatkoweUslugi>();
            while (rdr.Read())
            {

                uslugi.Id_uslugi = (int)rdr["id_uslugi"];
                uslugi.Nazwa = (string)rdr["nazwa"];
                uslugi.Opis = (string)rdr["opis"];
                uslugi.Cena = (decimal)rdr["cena"];
                uslugi.Czy_w_cenie = (bool)rdr["czy_w_cenie"];



                listaDodatkoweUslugiow.Add(uslugi);
                uslugi = new DodatkoweUslugi();
            }
            rdr.Close();
            conn.Close();

            return listaDodatkoweUslugiow;
        }

        /// <summary>
        /// Funkcja dodaje nowy aktualnosci do tabeli "Aktualnosci" w bazie danych 
        /// </summary>
        /// <param name="aktualnosci">Obiekt Aktualnosci</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajAktualnosci(Aktualnosci aktualnosci)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_aktualnosci";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = aktualnosci.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = aktualnosci.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_dodania";
            param.Value = aktualnosci.Data_dodania;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = aktualnosci.Opis_skrot;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Aktualnosci z bazy danych na postawie id_aktualnosci
        /// </summary>
        /// <param name="idaktualnosci">Id aktualnosci to usnięcia</param>
        public void usunAktualnosci(int idaktualnosci)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_aktualnosci";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_aktualnosci";
            param.Value = idaktualnosci;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Aktualnosci w bazie danych
        /// </summary>
        /// <param name="aktualnosci">Obiekt aktualnosci zawierający inforamacje do aktualizacji</param>
        public void aktualizujAktualnosci(Aktualnosci aktualnosci)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_aktualnosci";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_aktualnosci";
            param.Value = aktualnosci.Id_aktualnosci;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = aktualnosci.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = aktualnosci.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_dodania";
            param.Value = aktualnosci.Data_dodania;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = aktualnosci.Opis_skrot;
            cmd.Parameters.Add(param);


            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera aktualnosci na podstawie id aktualnosci
        /// </summary>
        /// <param name="idaktualnosci">Id aktualnosci</param>
        /// <returns>Obiekt Aktualnosci</returns>
        public Aktualnosci pobierzAktualnosci(int idaktualnosci)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_aktualnosci";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_aktualnosci";
            param.Value = idaktualnosci;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Aktualnosci aktualnosci = new Aktualnosci();
            while (rdr.Read())
            {

                aktualnosci.Id_aktualnosci = (int)rdr["id_aktualnosci"];
                aktualnosci.Nazwa = (string)rdr["nazwa"];
                aktualnosci.Opis = (string)rdr["opis"];
                aktualnosci.Opis_skrot = (string)rdr["opis_skrot"];
                aktualnosci.Data_dodania = (DateTime)rdr["data_dodania"];
            }
            rdr.Close();
            conn.Close();

            return aktualnosci;
        }

        /// <summary>
        /// Funkcja zwracająca listę aktualnosciów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<Aktualnosci> pobierzListeAktualnosci()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_aktualnosci";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            Aktualnosci aktualnosci = new Aktualnosci();
            ObservableCollection<Aktualnosci> listaAktualnosci = new ObservableCollection<Aktualnosci>();
            while (rdr.Read())
            {

                aktualnosci.Id_aktualnosci = (int)rdr["id_aktualnosci"];
                aktualnosci.Nazwa = (string)rdr["nazwa"];
                aktualnosci.Opis = (string)rdr["opis"];                
                aktualnosci.Opis_skrot = (string)rdr["opis_skrot"];
                aktualnosci.Data_dodania = (DateTime)rdr["data_dodania"];


                listaAktualnosci.Add(aktualnosci);
                aktualnosci = new Aktualnosci();
            }
            rdr.Close();
            conn.Close();

            return listaAktualnosci;
        }

        /// <summary>
        /// Funkcja dodaje nowy promocja do tabeli "Promocja" w bazie danych 
        /// </summary>
        /// <param name="promocja">Obiekt Promocja</param>
        /// <returns>Wartość int zawierająca indeks ostatnio dodanego wiersza</returns>
        public int dodajPromocja(Promocja promocja)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();
            cmd.CommandText = "dodaj_promocja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@nazwa";
            param.Value = promocja.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = promocja.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_dodania";
            param.Value = promocja.Data_dodania;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = promocja.Opis_skrot;
            cmd.Parameters.Add(param);

            int indeksDodanegoWiersza = Convert.ToInt32(cmd.ExecuteScalar());
            conn.Close();
            return indeksDodanegoWiersza;
        }

        /// <summary>
        /// Funkcja usuwająca Promocja z bazy danych na postawie id_promocja
        /// </summary>
        /// <param name="idpromocja">Id promocja to usnięcia</param>
        public void usunPromocja(int idpromocja)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "usun_promocja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();
            param.ParameterName = "@id_promocja";
            param.Value = idpromocja;

            cmd.Parameters.Add(param);

            cmd.ExecuteNonQuery();

            conn.Close();
        }

        /// <summary>
        /// Funkcja akutualizująca Promocja w bazie danych
        /// </summary>
        /// <param name="promocja">Obiekt promocja zawierający inforamacje do aktualizacji</param>
        public void aktualizujPromocja(Promocja promocja)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "aktualizuj_promocja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            //parametry procedury

            param.ParameterName = "@id_promocja";
            param.Value = promocja.Id_promocja;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@nazwa";
            param.Value = promocja.Nazwa;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis";
            param.Value = promocja.Opis;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@data_dodania";
            param.Value = promocja.Data_dodania;
            cmd.Parameters.Add(param);

            param = provider.CreateParameter();
            param.ParameterName = "@opis_skrot";
            param.Value = promocja.Opis_skrot;
            cmd.Parameters.Add(param);


            cmd.ExecuteReader();
            conn.Close();

        }

        /// <summary>
        /// Pobiera promocja na podstawie id promocja
        /// </summary>
        /// <param name="idpromocja">Id promocja</param>
        /// <returns>Obiekt Promocja</returns>
        public Promocja pobierzPromocja(int idpromocja)
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_promocja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbParameter param = provider.CreateParameter();

            param.ParameterName = "@id_promocja";
            param.Value = idpromocja;
            cmd.Parameters.Add(param);

            DbDataReader rdr = cmd.ExecuteReader();

            Promocja promocja = new Promocja();
            while (rdr.Read())
            {

                promocja.Id_promocja = (int)rdr["id_promocja"];
                promocja.Nazwa = (string)rdr["nazwa"];
                promocja.Opis = (string)rdr["opis"];
                promocja.Opis_skrot = (string)rdr["opis_skrot"];
                promocja.Data_dodania = (DateTime)rdr["data_dodania"];
            }
            rdr.Close();
            conn.Close();

            return promocja;
        }

        /// <summary>
        /// Funkcja zwracająca listę promocjaów dostępnych w bazie danych
        /// </summary>
        public ObservableCollection<Promocja> pobierzListePromocja()
        {
            DbProviderFactory provider = DbProviderFactories.GetFactory(dbProvider);
            DbConnection conn = provider.CreateConnection();
            conn.ConnectionString = connectionString;

            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = conn;
            conn.Open();

            cmd.CommandText = "pobierz_liste_promocja";
            cmd.CommandType = CommandType.StoredProcedure;

            DbDataReader rdr = cmd.ExecuteReader();

            Promocja promocja = new Promocja();
            ObservableCollection<Promocja> listaPromocja = new ObservableCollection<Promocja>();
            while (rdr.Read())
            {

                promocja.Id_promocja = (int)rdr["id_promocja"];
                promocja.Nazwa = (string)rdr["nazwa"];
                promocja.Opis = (string)rdr["opis"];
                promocja.Opis_skrot = (string)rdr["opis_skrot"];
                promocja.Data_dodania = (DateTime)rdr["data_dodania"];


                listaPromocja.Add(promocja);
                promocja = new Promocja();
            }
            rdr.Close();
            conn.Close();

            return listaPromocja;
        }
    
    }
}
